/*
* 作者：陆蕙诗
*
* 班级：15计算机科学与技术
*
* 学号：150201101878
*
* 实现功能：两个操作数的计算器
*
* */

package com.example.beauty.calcultor;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class Calculator extends AppCompatActivity implements View.OnClickListener{

    TextView tv_formula;
    Button btn0,btn1,btn2,btn3,btn4,btn5,btn6,btn7,btn8,btn9;
    Button btn_doc,btn_add,btn_sub,btn_mul,btn_div, btn_neg,
            btn_equ,btn_allClear,btn_del;

    double num1,num2;   //存放两个操作数
    double result=0;      //存放结果,初始化为0
    int op;             //操作符标志，1:加,2:减,3:乘,4:除
    boolean isClickEqu=false;   //等于键标志，true:按下等于键
    String str_cur;     //储存tv_formula当前的数字
    String str_res;     //存储运算结果
    String str_temp;    //点击负数按键时，存储操作数前的字符串
    String str_neg="-";     //正负数操作号
    String str_old;     //保存多个操作符表达式的字符串
    boolean isClickNeg=false;   //负数标志，true:是负数

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_calculator);
        /*接收控件*/
        tv_formula=(TextView)findViewById(R.id.tv_formula);
        btn0=(Button)findViewById(R.id.btn0);
        btn1=(Button)findViewById(R.id.btn1);
        btn2=(Button)findViewById(R.id.btn2);
        btn3=(Button)findViewById(R.id.btn3);
        btn4=(Button)findViewById(R.id.btn4);
        btn5=(Button)findViewById(R.id.btn5);
        btn6=(Button)findViewById(R.id.btn6);
        btn7=(Button)findViewById(R.id.btn7);
        btn8=(Button)findViewById(R.id.btn8);
        btn9=(Button)findViewById(R.id.btn9);
        btn_add=(Button)findViewById(R.id.btn_add);
        btn_sub=(Button)findViewById(R.id.btn_sub);
        btn_mul=(Button)findViewById(R.id.btn_mul);
        btn_div=(Button)findViewById(R.id.btn_div);
        btn_doc=(Button)findViewById(R.id.btn_doc);
        btn_del=(Button)findViewById(R.id.btn_del);
        btn_allClear=(Button)findViewById(R.id.btn_allClear);
        btn_equ=(Button)findViewById(R.id.btn_equ);
        btn_neg=(Button)findViewById(R.id.btn_neg);

        /*添加按钮监听*/
        btn0.setOnClickListener(this);
        btn1.setOnClickListener(this);
        btn2.setOnClickListener(this);
        btn3.setOnClickListener(this);
        btn4.setOnClickListener(this);
        btn5.setOnClickListener(this);
        btn6.setOnClickListener(this);
        btn7.setOnClickListener(this);
        btn8.setOnClickListener(this);
        btn9.setOnClickListener(this);
        btn_add.setOnClickListener(this);
        btn_sub.setOnClickListener(this);
        btn_mul.setOnClickListener(this);
        btn_div.setOnClickListener(this);
        btn_allClear.setOnClickListener(this);
        btn_del.setOnClickListener(this);
        btn_doc.setOnClickListener(this);
        btn_neg.setOnClickListener(this);
        btn_equ.setOnClickListener(this);


    }

    @Override
    public void onClick(View v){
        switch(v.getId()){

            /*清除按钮监听事件：
            * C是把内容变为0，左键号是清除1个字符。
            * */
            case R.id.btn_allClear:
                Log.d("Calculator","把tv_formula的内容变为0");
                str_cur="0";
                tv_formula.setText(str_cur);
                break;

            case R.id.btn_del:
                Log.d("Calculator","把tv_formula的内容从右边开始裁剪1个字符");
                //获取当前tv_formula的内容
                str_cur = tv_formula.getText().toString();
                if(str_cur.isEmpty()){
                    return;
                }
                //裁剪1个字符,若不赋值给str_cur，裁剪操作对str_cur的字符串无影响
                str_cur=str_cur.substring(0,str_cur.length()-1);
                tv_formula.setText(str_cur);
                break;

            /*数字按钮x监听事件：
            * 如果tv_formula内容不是运算结果，又不是只有0，则字符串末尾连接
            * 数字x，把等于键标识变为false
            * */
            case R.id.btn0:
                //获取当前tv_formula的内容
                str_cur = tv_formula.getText().toString();
                /*若tv_formula内容是运算结果，清空内容*/
                if(isClickEqu)
                {
                    Log.d("Calculator","tv_formula的内容是运算结果");
                    str_cur="";
                }
                /*防止重复按0*/
                else if(str_cur.equals("0"))
                {
                    Log.d("Calculator","tv_formula的内容是“0”");
                    return;
                }
                /*不是上述特殊情况时，字符串末尾连接0*/
                else
                {
                    Log.d("Calculator","tv_formula的内容既不是0，又不是运算结果");
                }
                str_cur+="0";
                tv_formula.setText(str_cur);
                Log.d("Calculator","连接0后的字符串："+str_cur);
                isClickEqu=false;       //把等于键标识变为假
                break;

            case R.id.btn1:
                //获取当前tv_formula的内容
                str_cur = tv_formula.getText().toString();
                /*若tv_formula内容是运算结果，清空内容*/
                if(isClickEqu)
                {
                    Log.d("Calculator","tv_formula的内容是运算结果");
                    str_cur="";
                }
                /*若tv_formula内容只有0，且不是运算结果时，先清空内容*/
                else if(str_cur.equals("0"))
                {
                    Log.d("Calculator","tv_formula的内容是“0”");
                    str_cur="";
                }
                /*不是上述特殊情况时，字符串末尾连接1*/
                else
                {
                    Log.d("Calculator","tv_formula的内容既不是0，又不是运算结果");
                }
                str_cur+="1";
                tv_formula.setText(str_cur);
                Log.d("Calculator","连接1后的字符串："+str_cur);
                isClickEqu=false;       //把等于键标识变为假
                break;

            case R.id.btn2:
                //获取当前tv_formula的内容
                str_cur = tv_formula.getText().toString();
                /*若tv_formula内容是运算结果，清空内容*/
                if(isClickEqu)
                {
                    Log.d("Calculator","tv_formula的内容是运算结果");
                    str_cur="";
                }
                /*若tv_formula内容只有0，且不是运算结果时，先清空内容*/
                else if(str_cur.equals("0"))
                {
                    Log.d("Calculator","tv_formula的内容是“0”");
                    str_cur="";
                }
                /*不是上述特殊情况时，字符串末尾连接2*/
                else
                {
                    Log.d("Calculator","tv_formula的内容既不是0，又不是运算结果");
                }
                str_cur+="2";
                tv_formula.setText(str_cur);
                Log.d("Calculator","连接2后的字符串："+str_cur);
                isClickEqu=false;       //把等于键标识变为假
                break;

            case R.id.btn3:
                //获取当前tv_formula的内容
                str_cur = tv_formula.getText().toString();
                /*若tv_formula内容是运算结果，清空内容*/
                if(isClickEqu)
                {
                    Log.d("Calculator","tv_formula的内容是运算结果");
                    str_cur="";
                }
                /*若tv_formula内容只有0，且不是运算结果时，先清空内容*/
                else if(str_cur.equals("0"))
                {
                    Log.d("Calculator","tv_formula的内容是“0”");
                    str_cur="";
                }
                /*不是上述特殊情况时，字符串末尾连接3*/
                else
                {
                    Log.d("Calculator","tv_formula的内容既不是0，又不是运算结果");
                }
                str_cur+="3";
                tv_formula.setText(str_cur);
                Log.d("Calculator","连接3后的字符串："+str_cur);
                isClickEqu=false;       //把等于键标识变为假
                break;

            case R.id.btn4:
                //获取当前tv_formula的内容
                str_cur = tv_formula.getText().toString();
                /*若tv_formula内容是运算结果，清空内容*/
                if(isClickEqu)
                {
                    Log.d("Calculator","tv_formula的内容是运算结果");
                    str_cur="";
                }
                /*若tv_formula内容只有0，且不是运算结果时，先清空内容*/
                else if(str_cur.equals("0"))
                {
                    Log.d("Calculator","tv_formula的内容是“0”");
                    str_cur="";
                }
                /*不是上述特殊情况时，字符串末尾连接4*/
                else
                {
                    Log.d("Calculator","tv_formula的内容既不是0，又不是运算结果");
                }
                str_cur+="4";
                tv_formula.setText(str_cur);
                Log.d("Calculator","连接4后的字符串："+str_cur);
                isClickEqu=false;       //把等于键标识变为假
                break;

            case R.id.btn5:
                //获取当前tv_formula的内容
                str_cur = tv_formula.getText().toString();
                /*若tv_formula内容是运算结果，清空内容*/
                if(isClickEqu)
                {
                    Log.d("Calculator","tv_formula的内容是运算结果");
                    str_cur="";
                }
                /*若tv_formula内容只有0，且不是运算结果时，先清空内容*/
                else if(str_cur.equals("0"))
                {
                    Log.d("Calculator","tv_formula的内容是“0”");
                    str_cur="";
                }
                /*不是上述特殊情况时，字符串末尾连接5*/
                else
                {
                    Log.d("Calculator","tv_formula的内容既不是0，又不是运算结果");
                }
                str_cur+="5";
                tv_formula.setText(str_cur);
                Log.d("Calculator","连接5后的字符串："+str_cur);
                isClickEqu=false;       //把等于键标识变为假
                break;

            case R.id.btn6:
                //获取当前tv_formula的内容
                str_cur = tv_formula.getText().toString();
                /*若tv_formula内容是运算结果，清空内容*/
                if(isClickEqu)
                {
                    Log.d("Calculator","tv_formula的内容是运算结果");
                    str_cur="";
                }
                /*若tv_formula内容只有0，且不是运算结果时，先清空内容*/
                else if(str_cur.equals("0"))
                {
                    Log.d("Calculator","tv_formula的内容是“0”");
                    str_cur="";
                }
                /*不是上述特殊情况时，字符串末尾连接6*/
                else
                {
                    Log.d("Calculator","tv_formula的内容既不是0，又不是运算结果");
                }
                str_cur+="6";
                tv_formula.setText(str_cur);
                Log.d("Calculator","连接6后的字符串："+str_cur);
                isClickEqu=false;       //把等于键标识变为假
                break;

            case R.id.btn7:
                //获取当前tv_formula的内容
                str_cur = tv_formula.getText().toString();
                /*若tv_formula内容是运算结果，清空内容*/
                if(isClickEqu)
                {
                    Log.d("Calculator","tv_formula的内容是运算结果");
                    str_cur="";
                }
                /*若tv_formula内容只有0，且不是运算结果时，先清空内容*/
                else if(str_cur.equals("0"))
                {
                    Log.d("Calculator","tv_formula的内容是“0”");
                    str_cur="";
                }
                /*不是上述特殊情况时，字符串末尾连接7*/
                else
                {
                    Log.d("Calculator","tv_formula的内容既不是0，又不是运算结果");
                }
                str_cur+="7";
                tv_formula.setText(str_cur);
                Log.d("Calculator","连接7后的字符串："+str_cur);
                isClickEqu=false;       //把等于键标识变为假
                break;

            case R.id.btn8:
                //获取当前tv_formula的内容
                str_cur = tv_formula.getText().toString();
                /*若tv_formula内容是运算结果，清空内容*/
                if(isClickEqu)
                {
                    Log.d("Calculator","tv_formula的内容是运算结果");
                    str_cur="";
                }
                /*若tv_formula内容只有0，且不是运算结果时，先清空内容*/
                else if(str_cur.equals("0"))
                {
                    Log.d("Calculator","tv_formula的内容是“0”");
                    str_cur="";
                }
                /*不是上述特殊情况时，字符串末尾连接8*/
                else
                {
                    Log.d("Calculator","tv_formula的内容既不是0，又不是运算结果");
                }
                str_cur+="8";
                tv_formula.setText(str_cur);
                Log.d("Calculator","连接8后的字符串："+str_cur);
                isClickEqu=false;       //把等于键标识变为假
                break;

            case R.id.btn9:
                //获取当前tv_formula的内容
                str_cur = tv_formula.getText().toString();
                /*若tv_formula内容是运算结果，清空内容*/
                if(isClickEqu)
                {
                    Log.d("Calculator","tv_formula的内容是运算结果");
                    str_cur="";
                }
                /*若tv_formula内容只有0，且不是运算结果时，先清空内容*/
                else if(str_cur.equals("0"))
                {
                    Log.d("Calculator","tv_formula的内容是“0”");
                    str_cur="";
                }
                /*不是上述特殊情况时，字符串末尾连接9*/
                else
                {
                    Log.d("Calculator","tv_formula的内容既不是0，又不是运算结果");
                }
                str_cur+="9";
                tv_formula.setText(str_cur);
                Log.d("Calculator","连接9后的字符串："+str_cur);
                isClickEqu=false;       //把等于键标识变为假
                break;

            case R.id.btn_doc:
                //获取当前tv_formula的内容
                str_cur = tv_formula.getText().toString();
                /*若tv_formula内容是运算结果，自动加0*/
                if(isClickEqu)
                {
                    Log.d("Calculator","tv_formula的内容是运算结果");
                    str_cur="0";
                }
                /*若tv_formula内容只有0，且不是运算结果时，先清空内容*/
                else if(str_cur.substring(str_cur.length()-1)==".")
                {
                    Log.d("Calculator","tv_formula的内容已经含有“.”，return");
                    return;
                }
                /*不是上述特殊情况时，字符串末尾连接"."*/
                else
                {
                    Log.d("Calculator","tv_formula的内容既不含“.”,又不是运算结果");
                }
                str_cur+=".";
                tv_formula.setText(str_cur);
                Log.d("Calculator","连接.后的字符串："+str_cur);
                isClickEqu=false;       //把等于键标识变为假
                break;

            /*操作符监听事件：
            * 把tv_formula的值存入操作数num1
            **/
            case R.id.btn_add:
                Log.d("Calculator","点击+号");
                str_cur=tv_formula.getText().toString();
                //tv_formula的内容为空时，点击符号无效
                if(str_cur.isEmpty())
                {
                    return;
                }
                num1=Double.parseDouble(str_cur);
                //把tv_formula的内容末尾连接+号
                str_cur+="+";
                tv_formula.setText(str_cur);
                op=1;
                break;

            case R.id.btn_sub:
                Log.d("Calculator","点击-号");
                str_cur=tv_formula.getText().toString();
                //tv_formula的内容为空时，点击符号无效
                if(str_cur.isEmpty())
                {
                    return;
                }
                num1=Double.parseDouble(str_cur);
                //把tv_formula的内容末尾连接-号
                str_cur+="-";
                tv_formula.setText(str_cur);
                op=2;
                break;

            case R.id.btn_mul:
                Log.d("Calculator","点击x号");
                str_cur=tv_formula.getText().toString();
                //tv_formula的内容为空时，点击符号无效
                if(str_cur.isEmpty())
                {
                    return;
                }
                num1=Double.parseDouble(str_cur);
                //把tv_formula的内容末尾连接x号
                str_cur+="x";
                tv_formula.setText(str_cur);
                op=3;
                break;

            case R.id.btn_div:
                Log.d("Calculator","点击/号");
                str_cur=tv_formula.getText().toString();
                //tv_formula的内容为空时，点击符号无效
                if(str_cur.isEmpty())
                {
                    return;
                }
                num1=Double.parseDouble(str_cur);
                //把tv_formula的内容末尾连接+号
                str_cur+="/";
                tv_formula.setText(str_cur);
                op=4;
                break;

            case R.id.btn_neg:
                str_cur=tv_formula.getText().toString();
                if(str_cur.isEmpty())
                {
                    return;
                }
                //操作数是正数，加-号
                if(!isClickNeg)
                {
                    switch (op)
                    {
                        case 1:
                            Log.d("Calculator","操作符+号后的数加负号");
                            //存储到+号的字符串
                            str_temp=str_cur.substring(0,str_cur.indexOf("+")+1);
                            //存储+号后的操作数
                            str_cur=str_cur.substring(str_cur.indexOf("+")+1);
                            //给操作数加上-号
                            str_cur=str_neg+str_cur;
                            //拼接整个表达式
                            str_cur=str_temp+str_cur;
                            tv_formula.setText(str_cur);
                            isClickNeg=true;
                            break;
                        case 2:
                            Log.d("Calculator","操作符-号后的数加负号");
                            //存储到-号的字符串
                            str_temp=str_cur.substring(0,str_cur.indexOf("-")+1);
                            //存储-号后的操作数
                            str_cur=str_cur.substring(str_cur.indexOf("-")+1);
                            //给操作数加上-号
                            str_cur=str_neg+str_cur;
                            //拼接整个表达式
                            str_cur=str_temp+str_cur;
                            tv_formula.setText(str_cur);
                            isClickNeg=true;
                            break;
                        case 3:
                            Log.d("Calculator","操作符x号后的数加负号");
                            //存储到x号的字符串
                            str_temp=str_cur.substring(0,str_cur.indexOf("x")+1);
                            //存储x号后的操作数
                            str_cur=str_cur.substring(str_cur.indexOf("x")+1);
                            //给操作数加上-号
                            str_cur=str_neg+str_cur;
                            //拼接整个表达式
                            str_cur=str_temp+str_cur;
                            tv_formula.setText(str_cur);
                            isClickNeg=true;
                            break;
                        case 4:
                            Log.d("Calculator","操作符/号后的数加负号");
                            //存储到/号的字符串
                            str_temp=str_cur.substring(0,str_cur.indexOf("/")+1);
                            //存储/号后的操作数
                            str_cur=str_cur.substring(str_cur.indexOf("/")+1);
                            //给操作数加上-号
                            str_cur=str_neg+str_cur;
                            //拼接整个表达式
                            str_cur=str_temp+str_cur;
                            tv_formula.setText(str_cur);
                            isClickNeg=true;
                            break;
                        default:
                            Log.d("Calculator","操作符+号后的数加负号");
                            //给操作数加上-号
                            str_cur=str_neg+str_cur;
                            tv_formula.setText(str_cur);
                            isClickNeg=true;
                            break;
                    }
                }
                //操作数是负数,去掉负号
                else
                {
                    //存储负号前的字符串
                    str_temp=str_cur.substring(0,str_cur.indexOf(str_neg));
                    //存储负号后的操作数
                    str_cur=str_cur.substring(str_cur.indexOf(str_neg)+1);
                    //拼接整个表达式
                    str_cur=str_temp+str_cur;
                    tv_formula.setText(str_cur);
                    //清楚负数标识位
                    isClickNeg=false;
                }
                break;

            case R.id.btn_equ:
                switch (op)
                {
                    //加法
                    case 1:
                        str_cur=tv_formula.getText().toString();
                        //截取+号之后的字符
                        str_cur=str_cur.substring(str_cur.indexOf("+")+1);
                        num2=Double.parseDouble(str_cur);
                        result=num1+num2;
                        str_res=Double.toString(result);
                        tv_formula.setText(str_res);
                        //把等于号标识置位
                        isClickEqu=true;
                        //还原op的值
                        op=0;
                        break;
                    //减法
                    case 2:
                        str_cur=tv_formula.getText().toString();
                        //截取-号之后的字符
                        str_cur=str_cur.substring(str_cur.indexOf("-")+1);
                        num2=Double.parseDouble(str_cur);
                        result=num1-num2;
                        str_res=Double.toString(result);
                        tv_formula.setText(str_res);
                        //把等于号标识置位
                        isClickEqu=true;
                        //还原op的值
                        op=0;
                        break;
                    //乘法
                    case 3:
                        str_cur=tv_formula.getText().toString();
                        //截取x号之后的字符
                        str_cur=str_cur.substring(str_cur.indexOf("x")+1);
                        num2=Double.parseDouble(str_cur);
                        result=num1*num2;
                        str_res=Double.toString(result);
                        tv_formula.setText(str_res);
                        //把等于号标识置位
                        isClickEqu=true;
                        //还原op的值
                        op=0;
                        break;
                    //除法
                    case 4:
                        str_cur=tv_formula.getText().toString();
                        //截取+号之后的字符
                        str_cur=str_cur.substring(str_cur.indexOf("/")+1);
                        num2=Double.parseDouble(str_cur);
                        result=num1/num2;
                        str_res=Double.toString(result);
                        tv_formula.setText(str_res);
                        //把等于号标识置位
                        isClickEqu=true;
                        //还原op的值
                        op=0;
                        break;
                    default:
                        break;
                }
                break;

            default:
                break;
        }
    }

}
